// 质数判断函数
function isPrimeNumber(number) {
    for (var i = 2; i <= number - 1; i++) {
        if (number % i === 0) {
            return false;
        }
    }
    return true;
}

// 数组去重 indexOf()方法
// 参数: 需要执行数值去重的数组
function getNewArr1(array) {
    // 创建新数组
    var newArr = [];

    // 循环遍历原始数组 
    for (var i = 0; i <= array.length - 1; i++) {
        // 新数组中 没有 当前索引下标存储的数据 再执行写入操作
        if (newArr.indexOf(array[i]) === -1) {
            newArr.push(array[i])
        }
    }
    // 返回新数组
    return newArr;
}


// 数组去重 对象特性方法
// 参数: 需要执行数值去重的数组
function getNewArr2(array) {
    // 创建新数组
    var newArr = [];

    // 创建一个新对象
    var obj = {};

    // 循环遍历 原始数组 将数据设定为对象的属性 属性值随便
    array.forEach(function (val) {
        obj[val] = '';
    })

    // 循环遍历 对象 将 属性 作为 数据 写入新数组
    for (var key in obj) {
        newArr.push(key);
    }

    // 返回新数组
    return newArr;
}

// 数组去重 排序方法
// 参数: 需要执行数值去重的数组
function getNewArr3(array) {
    // 1, 数组排序
    array.sort(function (a, b) { return a - b })

    // 2, 循环遍历

    // 最后一个单元 没有下一个单元 比较判断 
    // 循环至 倒数第二个单元就可以了 array.length-1-1
    for (var i = 0; i <= array.length - 1 - 1; i++) {
        // 当前单元i 下一个单元 i+1 比较判断数值
        if (array[i] === array[i + 1]) {
            // 从 i+1 开始删除一个单元
            array.splice(i + 1, 1);
            // 为了防止数组坍塌的影响
            i--;
        }
    }

    // 3, 返回删除单元后的数组
    return array;
}

// 数组去重 双重for循环
function getNewArr4(array) {
    // 从第一个单元 循环至 倒数第二个单元
    for (var i = 0; i <= array.length - 1 - 1; i++) {
        // 从 外层循环单元 的下一个单元 循环至 最后一个单元
        for (var j = i + 1; j <= array.length - 1; j++) {
            // 如果 外层索引下标 对应数据 和 内层索引下标 对应数据 相同
            if (array[i] === array[j]) {
                // 从 内层索引下标位置 开始 删除1个单元
                array.splice(j, 1);
                // 消除 数组坍塌 造成的 影响
                j--;
            }
        }
    }
    return array;
}


// 随机验证码
// 参数1: 验证码位数 设定默认值是 6
// 参数2: 验证码内容 设定默认值 数字 小写字母 大写字母
// 参数3: 验证码内容 是否可以重复 默认值是 true 可以重复
function setVc(num = 6, string = '0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ', bool = true) {
    // 定义字符串 存储验证码内容
    var vc = '';

    // 循环 vc字符串的字符个数 等于 设定的验证码位数num
    while (vc.length !== num) {
        // 生成 随机索引下标 范围是 0 至 验证码内容字符串.length-1
        var index = parseInt(Math.random() * string.length);

        // 如果 参数3 bool 是 true 就是 可以 有重复字符 获取的随机字符直接拼接
        // 如果 参数3 bool 是 false 就是 不能有重负字符 获取的随机字符验证之后再拼接
        if (bool) {
            // 可以有重复字符 直接拼接
            vc += string[index];
        } else {
            // 不允许有重复字符 string[index] 不在 vc 中 再拼接
            if (vc.indexOf(string[index]) === -1) {
                vc += string[index];
            }
        }

    }

    // 返回值是验证码字符串
    return vc;

}

// 随机颜色1 rgb
function setRgb() {
    return `rgb(${parseInt(Math.random() * 256)},${parseInt(Math.random() * 256)},${parseInt(Math.random() * 256)})`;
}


// 随机颜色2 rgba

function setRgba() {
    return `rgba(${parseInt(Math.random() * 256)},${parseInt(Math.random() * 256)},${parseInt(Math.random() * 256)},${parseInt(Math.random() * 11) / 10})`;
}


// 封装成函数的形式 输入 时间字符串 返回具体的时间数据
function getTimeObj(timeString) {
    // 1, 创建时间对象
    var time = timeString === undefined ? new Date() : new Date(timeString);

    // 星期数组
    var arr = ['星期日', '星期一', '星期二', '星期三', '星期四', '星期五', '星期六'];

    // 2, 返回时间对象信息
    // 星期是 中文 时分秒 有 前导补零
    return {
        year: time.getFullYear(),
        month: time.getMonth() + 1,
        day: time.getDate(),
        week: arr[time.getDay()],
        hours: time.getHours() < 10 ? '0' + time.getHours() : time.getHours(),
        minutes: time.getMinutes() < 10 ? '0' + time.getMinutes() : time.getMinutes(),
        seconds: time.getSeconds() < 10 ? '0' + time.getSeconds() : time.getSeconds(),
    };
}


// 计算时间差 返回值是对象形式
// 参数: 终止时间 时间字符串
function TD(end){
    // 创建 起始 和 终止 时间对象
    var startTime = new Date();
    var endTime = new Date(end);

    // 计算时间差
    var time = parseInt( ( endTime.getTime() - startTime.getTime() ) / 1000 );

    // 返回时间差 转化的 天 小时 分钟 秒
    return {
        day: parseInt( time / (24*60*60) ),
        hours: parseInt( time % (24*60*60) / (60*60) ),
        minutes: parseInt( time % (60*60) / 60 ),
        seconds:time % 60,
    };
}


// 获取 css样式 方法函数
// 参数1: 标签对象
// 参数2: css属性
// 返回值是 css属性值
function myGetStyle(element , type){
    if(window.getComputedStyle){
        // 普通浏览器语法
        return window.getComputedStyle(element)[type];
    }else{
        // 低版本IE浏览器语法
        return element.currentStyle[type];
    }
}


// 获取浏览器地址栏数据参数
function getUrlVal(){
    // 1, 定义一个对象
    var obj = {};

    // 2, 获取浏览器地址栏中携带的参数数据
    // 第一个?问号不要
    var str = window.location.search.substr(1);

    // 3, 将字符串键值对按照 & 符号为间隔转化为数组
    var arr1 = str.split('&');

    // 4, 循环遍历arr1 将单元的数据也就是 键值对字符串 
    // 按照 = 等号 转化为数组
    // 数组索引0单元 存储 键名 -- 设定给对象的键名
    // 数组索引1单元 存储 键值 -- 键值给对象的键值 需要还原为中文/特殊符号
    arr1.forEach( function(item){
        var arr2 = item.split('=');
        obj[ arr2[0] ] = window.decodeURIComponent( arr2[1] );
    })

    // 5, 返回这个对象
    return obj;

}


// 封装运动函数
// 参数1: 运动的标签对象
// 参数2: 运动的属性和最终数值
// 参数3: 运动结束 执行的回调函 默认值是空函数
function move( element , object , cb = function(){} ){
    // 1 , 定义变量 存储多属性运动 定时器个数
    let num = 0;

    // 2 , 循环遍历 参数2 获取运动属性 和 最终数值
    // let 声明 循环变量
    for( let type in object ){
        // 2-1 num累加
        num++;

        // 2-2 获取 标签对象当前属性的初始值 兼容透明度
        let startVal = type === 'opacity' ? myGetStyle( element , type)*100 : parseInt( myGetStyle( element , type) );
        
        // 2-3 获取 最终数值 兼容透明度
        let endVal = type === 'opacity' ? object[type]*100 : object[type];

        // 2-4 定义定时器 计算步长 步长取整 执行累加 赋值属性值 判断清除定时器
        let time = setInterval( ()=>{

            // 2-4-1 计算步长
            let step = ( endVal - startVal ) / 10 ;

            // 2-4-2 步长取整 大于0,向上取整 小于0,向下取整
            step = step > 0 ? Math.ceil(step) : Math.floor(step);

            // 2-4-3 累加步长
            startVal += step;

            // 2-4-4 赋值属性值 兼容透明度
            element.style[type] = type === 'opacity' ? startVal/100 : startVal + 'px';

            // 2-4-5 到达最终数值 清除定时器
            if( startVal === endVal ){
                // 清除定时器
                clearInterval(time);

                // 变量--
                num--;

                // 如果num是0 证明所有运动停止了
                if(num === 0){
                    // 执行回调函数
                    cb();
                }
            }
        } , 20)

    } 
}